const { http } = require('../../../utils/http'); 
import {
  getCurrentUser
} from '../../../utils/userManager';
Page({

  /**
   * 页面的初始数据
   */
  data: {
    noteCount: 1,
    initialNoteCount: 0, // 存储首次加载的总笔记数
    initialTodayNotes: 0, // 新增：存储首次加载的今日笔记数
    categoryCount: 7,
    todayNotes: 4,
    noteList: [],
    selectedCategory: '',
    loading: false,        // 加载状态
    loginUser:'',
    content: '',  // 新增搜索内容字段
    activeCategory: "", // 记录当前选中的分类（初始选中“全部”）
    showNoteModal: false, // 控制弹出框显示隐藏
    page: 1,         // 当前页码，初始为第 1 页
    pageSize: 5,    // 每页条数
    hasMore: true    // 是否还有更多数据
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    this.getNoteList();
  },
  
  /**
   * 获取笔记列表数据 - 移除去重处理
   */
  getNoteList() {
    this.setData({ loading: true });
    wx.showLoading({ title: '加载中...' });

    const params = {
      subjectName: this.data.selectedCategory,
      userId: getCurrentUser().userInfo.userId,
      content: this.data.content,
      pageNum: this.data.page,
      pageSize: this.data.pageSize
    };

    http.get('/wjq/note/list', params)
      .then(res => {
         console.log('请求参数:', params);
         console.log('当前页码:', this.data.page);
         console.log('接口返回数据:', res)
        if (res.code === 200) {
          const noteListData = res.rows || [];
          const todayNotesCount = this.filterTodayNotes(noteListData);
          
          // 直接拼接数据，不做去重处理
          let newNoteList = this.data.noteList;
          if (this.data.page === 1) {
             newNoteList = noteListData; // 第一页直接使用新数据
             
             // 首次加载时记录总笔记数和今日笔记数
             if (this.data.initialNoteCount === 0) {
               this.setData({
                 initialNoteCount: res.total,
                 initialTodayNotes: todayNotesCount // 存储首次今日笔记数
               });
             }
           } else {
            newNoteList = newNoteList.concat(noteListData); // 后续页追加数据
           }

          // 判断是否还有更多数据（根据返回的总条数和当前列表长度）
          this.setData({
              noteList: newNoteList,
              noteCount: this.data.initialNoteCount || res.total, // 使用初始总笔记数
              todayNotes: this.data.initialTodayNotes || todayNotesCount, // 使用初始今日笔记数
              // 当总长度小于后端返回的总数时，认为还有更多
              hasMore: newNoteList.length < res.total
          });
        } else {
          wx.showToast({ title: res.msg || '获取失败', icon: 'none' });
        }
      })
      .catch(err => {
        console.error('请求失败:', err);
        wx.showToast({ title: '网络异常', icon: 'none' });
      })
      .finally(() => {
        this.setData({ loading: false });
        wx.hideLoading();
      });
  },


  /**
   * 切换分类标签
   */
  switchCategory(e) {
    const category = e.currentTarget.dataset.category;
    this.setData({
      activeCategory: category,
      selectedCategory: category,
      noteList: [],
      page: 1,       // 重置页码
      hasMore: true
    });
    this.getNoteList(); 
  },

  /**
   * 查看笔记详情
   */
  openNoteModal(e) {
    const note = e.currentTarget.dataset.note;
    if (!note) {
      wx.showToast({ title: '数据加载失败', icon: 'none' });
      return;
    }
    
    const analysisContent = note.questionOption?.analysis || '暂无解析内容';
    
    this.setData({
      showNoteModal: true,
      currentNote: {
        id: note.id,
        question: { title: note.question?.title || '无标题' },
        analysis: analysisContent,
        noteContent: note.content || '',
        updateTime: note.updateTime // 新增：保存笔记更新时间用于删除判断
      }
    });
  },

  // 关闭笔记弹出框
  closeNoteModal() {
    this.setData({
      showNoteModal: false
    });
  },

  // 笔记内容改变事件
  onNoteContentChange(e) {
    this.setData({
      'currentNote.noteContent': e.detail.value
    });
  },

  /**
   * 删除笔记事件
   */
  deleteNote() {
    const { currentNote } = this.data;
    
    if (!currentNote || !currentNote.id) {
      wx.showToast({ title: '数据异常，无法删除', icon: 'none' });
      return;
    }

    wx.showModal({
      title: '确认删除',
      content: '确定要删除这条笔记吗？删除后不可恢复。',
      confirmText: '删除',
      confirmColor: '#f37b1d',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          http.delete(`/wjq/note/${currentNote.id}`)
            .then(res => {
              if (res.code === 200) {
                wx.showToast({ title: '删除成功', icon: 'success', duration: 1500 });
                this.closeNoteModal();
                
                const updatedNoteList = this.data.noteList.filter(
                  note => note.id !== currentNote.id
                );

                // 判断删除的是否是今日笔记
                const deleteNoteTime = new Date(currentNote.updateTime);
                const today = new Date();
                today.setHours(0, 0, 0, 0);
                const tomorrow = new Date(today);
                tomorrow.setDate(today.getDate() + 1);
                
                // 如果是今日笔记，更新今日笔记初始计数
                let newInitialTodayNotes = this.data.initialTodayNotes;
                if (deleteNoteTime >= today && deleteNoteTime < tomorrow) {
                  newInitialTodayNotes = Math.max(0, newInitialTodayNotes - 1);
                }

                this.setData({
                  noteList: updatedNoteList,
                  // 更新初始总笔记数
                  initialNoteCount: Math.max(0, this.data.initialNoteCount - 1),
                  noteCount: Math.max(0, this.data.initialNoteCount - 1),
                  // 更新初始今日笔记数
                  initialTodayNotes: newInitialTodayNotes,
                  todayNotes: newInitialTodayNotes
                });
              } else {
                wx.showToast({ title: res.msg || '删除失败', icon: 'none' });
              }
            })
            .catch(err => {
              console.error('删除接口调用失败:', err);
              wx.showToast({ title: '网络异常，删除失败', icon: 'none' });
            });
        }
      }
    });
  },

  /**
   * 保存笔记修改
   */
  saveNote() {
    const { currentNote, noteList } = this.data;
    
    if (!currentNote || !currentNote.id) {
      wx.showToast({ title: '数据异常，无法保存', icon: 'none' });
      return;
    }
    if (!currentNote.noteContent || currentNote.noteContent.trim() === '') {
      wx.showToast({ title: '笔记内容不能为空', icon: 'none' });
      return;
    }

    const updateData = {
      id: currentNote.id,
      content: currentNote.noteContent.trim(),
      subjectName: currentNote.subjectName || ''
    };

    http.put('/wjq/note', updateData)
      .then(res => {
        if (res.code === 200) {
          wx.showToast({ title: '保存成功', icon: 'success', duration: 1500 });
          
          const updatedNoteList = noteList.map(note => {
            if (note.id === currentNote.id) {
              return { 
                ...note, 
                content: updateData.content
              };
            }
            return note;
          });
          
          this.setData({
            noteList: updatedNoteList,
            showNoteModal: false
          });
        } else {
          wx.showToast({ title: res.msg || '保存失败', icon: 'none' });
        }
      })
      .catch(err => {
        console.error('调用修改接口失败:', err);
        wx.showToast({ title: '网络异常，保存失败', icon: 'none' });
      });
  },

  /**
   * 搜索笔记
   */
  onInputChange(e) {
    this.setData({
      content: e.detail.value
    })
  },
  
  handleSearch() {
    console.log('搜索内容:', this.data.content)
    this.setData({ 
      noteList: [], 
      page: 1,
      hasMore: true
    });
    this.getNoteList();
  },

  // 辅助方法：筛选今日笔记
  filterTodayNotes(noteList) {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const tomorrow = new Date(today);
    tomorrow.setDate(today.getDate() + 1);

    return noteList.filter(note => {
      const updateTime = new Date(note.updateTime);
      return updateTime >= today && updateTime < tomorrow;
    }).length;
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    this.setData({
      page: 1,
      hasMore: true
    });
    this.getNoteList().then(() => {
      wx.stopPullDownRefresh();
    });
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    if (this.data.hasMore && !this.data.loading) { 
      wx.showToast({
        title: '加载更多...',
        icon: 'none',
        duration: 1000
      });
      this.setData({
        page: this.data.page + 1
      });
      this.getNoteList();
    } else if (!this.data.hasMore) {
      wx.showToast({
        title: '没有更多数据了',
        icon: 'none',
        duration: 1000
      });
    }
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    const currentCategory = this.data.selectedCategory;
    const subjectInfo = this.data.subjects[currentCategory] || { name: '笔记' };
    
    return {
      title: `${subjectInfo.name}学习笔记 - 知识分享`,
      path: `/my/pages/Note/Note?category=${currentCategory}`,
      imageUrl: '/images/note-share.png'
    };
  }
})
